home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / src / wcedb.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  34.3 KB  |  1,462 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #include "wcedb.h"
  14.  
  15. #ifdef _DEBUG
  16. #undef THIS_FILE
  17. static char THIS_FILE[]=__FILE__;
  18. #define new DEBUG_NEW
  19. #endif
  20.  
  21. // The propid's HIWORD is the application-defined identifier (ident)
  22. // The propid's LOWORD is the datatype (CEVT_* values)
  23.  
  24. inline void SET_PROPID_CEVT(CEPROPID& propid,WORD wType)
  25. {
  26.     propid = MAKELONG(wType,HIWORD(propid));
  27. }
  28.  
  29. inline WORD GET_PROPID_CEVT(CEPROPID propid) 
  30. {
  31.     return LOWORD(propid);
  32. }
  33.  
  34. inline void SET_PROPID_IDENT(CEPROPID& propid,WORD wIdent)
  35. {
  36.     propid = MAKELONG(LOWORD(propid),wIdent);
  37. }
  38.  
  39. inline WORD GET_PROPID_IDENT(CEPROPID propid) 
  40. {
  41.     return HIWORD(propid);
  42. }
  43.  
  44. inline CEPROPID MAKE_PROPID(WORD wType,WORD wIndent)
  45. {
  46.     return MAKELONG(wType,wIndent);
  47. }
  48.  
  49. //////////////////////////////////////////////////////////////////////
  50. // CCeDBDatabase construction/Destruction
  51. //////////////////////////////////////////////////////////////////////
  52.  
  53. CCeDBDatabase::CCeDBDatabase()
  54. {
  55.     m_CEOID  = NULL;
  56.     m_hHandle = INVALID_HANDLE_VALUE;
  57.     m_bAutoSeekNext = FALSE;
  58.     m_bEOF = FALSE; // maintained via SeekNext() (so you should set
  59.                     // m_bAutoSeekNext if you want to use EOF() when 
  60.                     // reading records in sequentially)
  61. }
  62.  
  63.  
  64. CCeDBDatabase::~CCeDBDatabase()
  65. {
  66.     if(m_hHandle != INVALID_HANDLE_VALUE)
  67.         Close();
  68. }
  69.  
  70. //////////////////////////////////////////////////////////////////////
  71.  
  72.  
  73. //////////////////////////////////////////////////////////////////////
  74. // Basic operations
  75. //////////////////////////////////////////////////////////////////////
  76.  
  77. CEOID CCeDBDatabase::Create(LPCWSTR szName,
  78.                               DWORD dwIdent /*= 0*/,
  79.                               int nNumSortProps /*= 0*/,
  80.                               const CCeDBProp* pSortProps /*= NULL*/)
  81. {
  82.     AssertValidDbaseName(szName);  
  83.     ASSERT(m_hHandle == INVALID_HANDLE_VALUE);
  84.     ASSERT((nNumSortProps >= 0) && (nNumSortProps <= 4));
  85.     if(nNumSortProps == 0)
  86.         m_CEOID = CeCreateDatabase((LPWSTR)szName,dwIdent,0,NULL); 
  87.     else
  88.     {
  89.         ASSERT(pSortProps != NULL);
  90.         int i;
  91.  
  92.     // The WinCE database doesn't allow multiple sort keys on a single property,
  93.     // so check for it
  94. #ifdef _DEBUG
  95.         for(i=0; i < nNumSortProps-1; i++)
  96.             for(int j=i+1; j < nNumSortProps; j++)
  97.                 if(pSortProps[i].GetIdent() == pSortProps[j].GetIdent())
  98.                     ASSERT(FALSE); // A single property appeared more than once in the sort order!
  99. #endif
  100.  
  101.         SORTORDERSPEC Spec[4];
  102.         for(i=0; i < nNumSortProps; i++)
  103.         {
  104.             Spec[i].propid = pSortProps[i].GetPropid();
  105.             Spec[i].dwFlags = (DWORD)pSortProps[i].m_wSortFlags;
  106.         }
  107.  
  108.         WORD wCnt = (WORD)nNumSortProps;
  109.         m_CEOID = CeCreateDatabase((LPWSTR)szName,dwIdent,wCnt,Spec); 
  110.     }
  111.     
  112.     return m_CEOID;
  113. }
  114.  
  115.  
  116.  
  117. BOOL CCeDBDatabase::Open(CEOID CeOID,
  118.                           const CCeDBProp* pKeyProp /*= NULL*/, 
  119.                           const CWnd* pWndNotify /*= NULL*/)
  120. {
  121.     HWND hWnd;
  122.     CEPROPID propid = pKeyProp?pKeyProp->GetPropid():0;
  123.  
  124.     ASSERT(m_hHandle == INVALID_HANDLE_VALUE);
  125.  
  126.     if(pWndNotify == NULL)
  127.         hWnd = NULL;
  128.     else
  129.     {
  130. #ifdef _DEBUG
  131.         pWndNotify->AssertValid();
  132. #endif
  133.         hWnd = pWndNotify->GetSafeHwnd();
  134.     }
  135.  
  136.     m_CEOID = CeOID;
  137.     m_bEOF = FALSE;
  138.     m_hHandle = CeOpenDatabase(&m_CEOID,NULL,propid,0,hWnd);
  139.     return (m_hHandle != INVALID_HANDLE_VALUE);
  140. }
  141.  
  142.  
  143. BOOL CCeDBDatabase::Open(LPCWSTR szName,
  144.                           const CCeDBProp* pKeyProp /*= NULL*/, 
  145.                           const CWnd* pWndNotify /*= NULL*/)
  146. {
  147.     CEPROPID propid = pKeyProp?pKeyProp->GetPropid():0;
  148.     HWND hWnd;
  149.  
  150.     ASSERT(m_hHandle == INVALID_HANDLE_VALUE);
  151.  
  152.     if(pWndNotify == NULL)
  153.         hWnd = NULL;
  154.     else
  155.     {
  156. #ifdef _DEBUG
  157.         pWndNotify->AssertValid();
  158. #endif
  159.         hWnd = pWndNotify->GetSafeHwnd();
  160.     }
  161.     m_CEOID = 0;
  162.     m_bEOF = FALSE;
  163.     m_hHandle = CeOpenDatabase(&m_CEOID,(LPWSTR)szName,propid,0,hWnd);
  164.     return (m_hHandle != INVALID_HANDLE_VALUE);
  165. }
  166.  
  167.  
  168. BOOL CCeDBDatabase::Close() // Note, closing is optional, since the
  169.                            // destructor calls this automatically.
  170. {
  171.     if(m_hHandle == INVALID_HANDLE_VALUE)
  172.         return FALSE;
  173.  
  174.     if(!CloseHandle(m_hHandle))
  175.         return FALSE;
  176.  
  177.     m_hHandle = INVALID_HANDLE_VALUE;
  178.     return TRUE;
  179. }
  180.  
  181. BOOL CCeDBDatabase::Delete() // Note, we might want to make this a static function instead.
  182.                               // It's silly to open it, then delete it, but then again, we 
  183.                               // can take advantage of ref by name.
  184. {
  185.     ASSERT(m_CEOID != NULL);
  186.  
  187.     Close();
  188.  
  189.     if(!CeDeleteDatabase(m_CEOID))
  190.         return FALSE;
  191.  
  192.     m_CEOID = FALSE;
  193.     return TRUE;
  194. }
  195.  
  196. //////////////////////////////////////////////////////////////////////
  197.  
  198.  
  199.  
  200. //////////////////////////////////////////////////////////////////////
  201. // Static information functions (i.e. no open database used)
  202. //////////////////////////////////////////////////////////////////////
  203.  
  204. BOOL CCeDBDatabase::Exists(LPCWSTR szName)
  205. {
  206.     AssertValidDbaseName(szName);
  207.     
  208.     CEOID CeOID = NULL;
  209.  
  210.     // Note: this is a hack because we actually try to open it
  211.     // instead of using an existence function (I'm not sure if
  212.     // it exists.)
  213.     HANDLE hHandle = CeOpenDatabase(&CeOID,(LPWSTR)szName,0,0,NULL);
  214.  
  215.     // Need to find out what POD does when you give it a valid
  216.     // CeOID that is NOT a database.  If so, return FALSE.
  217.  
  218.     // Otherwise, this "hack" created a new resource, get rid of it
  219.     if(hHandle != INVALID_HANDLE_VALUE)
  220.     {
  221.         CloseHandle(hHandle); // not concerned about failure here
  222.         return TRUE;
  223.     }
  224.  
  225.     if(::GetLastError() == ERROR_FILE_NOT_FOUND)
  226.         return FALSE;
  227.  
  228.     // ASSUMPTION NOTE:
  229.     // The other expected error is ERROR_NOT_ENOUGH_MEMORY,
  230.     // we are assuming that the file exists in this case, i.e.
  231.     // CeOpenDatabase() DID find a file, BUT couldn't open it.
  232.  
  233.     return TRUE;
  234. }
  235.  
  236.  
  237.  
  238. BOOL CCeDBDatabase::Exists(CEOID CeOID)
  239. {
  240.     ASSERT(CeOID != NULL);
  241.  
  242.     // Note: this is a hack because we actually try to open it
  243.     // instead of using an existence function (I'm not sure if
  244.     // it exists.)
  245.     HANDLE hHandle = CeOpenDatabase(&CeOID,NULL,0,0,NULL);
  246.  
  247.     // Need to find out what POD does when you give it a valid
  248.     // CeOID that is NOT a database.  If so, return FALSE.
  249.  
  250.     // Otherwise, this "hack" created a new resource, get rid of it
  251.     if(hHandle != INVALID_HANDLE_VALUE)
  252.     {
  253.         CloseHandle(hHandle); // not concerned about failure here
  254.         return TRUE;
  255.     }
  256.  
  257.     if(::GetLastError() == ERROR_FILE_NOT_FOUND)
  258.         return FALSE;
  259.  
  260.     // ASSUMPTION NOTE:
  261.     // The other expected error is ERROR_NOT_ENOUGH_MEMORY,
  262.     // we are assuming that the file exists in this case, i.e.
  263.     // CeOpenDatabase() DID find a file, BUT couldn't open it.
  264.  
  265.     return FALSE;
  266. }
  267.  
  268. //////////////////////////////////////////////////////////////////////
  269.  
  270.  
  271.  
  272. //////////////////////////////////////////////////////////////////////
  273. // Database enumeration
  274. //////////////////////////////////////////////////////////////////////
  275.  
  276. CCeDBEnum::CCeDBEnum(DWORD dwIdent /*= 0*/)
  277. {
  278.     m_hHandle = CeFindFirstDatabase(dwIdent);
  279. }
  280.  
  281. CEOID CCeDBEnum::Next()
  282. {
  283.     if(m_hHandle == INVALID_HANDLE_VALUE)
  284.         return FALSE;
  285.  
  286.     return CeFindNextDatabase(m_hHandle);
  287. }
  288.  
  289. CCeDBEnum::~CCeDBEnum()
  290. {
  291.     if(m_hHandle != INVALID_HANDLE_VALUE)
  292.         CloseHandle(m_hHandle); 
  293. }
  294.  
  295. //////////////////////////////////////////////////////////////////////
  296.  
  297.  
  298.  
  299.  
  300. //////////////////////////////////////////////////////////////////////
  301. // Read/write/delete operations 
  302. //////////////////////////////////////////////////////////////////////
  303.  
  304. // O(1)
  305. BOOL CCeDBDatabase::ReadCurrRecord(CCeDBRecord* pRecord,
  306.                                       int nNumFilterProps /*= 0*/,
  307.                                      CCeDBProp* PropFilterArray /*= NULL*/)
  308. {
  309.     AssertValid();
  310.  
  311.     if(m_bAutoSeekNext && m_bEOF)
  312.     {
  313.         ::SetLastError(ERROR_HANDLE_EOF);
  314.         return FALSE; // no more records to read
  315.     }
  316.  
  317.     CEOID CeOID;
  318.     DWORD dwSize;
  319.     CEPROPID* inputPropIDArray = NULL;
  320.  
  321.     if(nNumFilterProps > 0)
  322.     {
  323.         TRY
  324.         {
  325.             inputPropIDArray = new CEPROPID[nNumFilterProps];
  326.         }
  327.         CATCH(CException,e)
  328.         {
  329.             ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  330.             return FALSE;
  331.         }
  332.         END_CATCH;
  333.  
  334.         for(int nCnt=0; nCnt < nNumFilterProps; nCnt++)
  335.             inputPropIDArray[nCnt] = PropFilterArray[nCnt].GetPropid(); 
  336.     }
  337.  
  338.     pRecord->FreeRecord();   // clear up this record before filling in again...
  339.                              // this will delete strings and blobs used by
  340.                              // the current properties in this record
  341.     
  342.     WORD wNumPropIdents = (WORD)nNumFilterProps;
  343.  
  344.     // NOTE: this will return the last record even if the seek has gone off the edge.
  345.  
  346.     CeOID = CeReadRecordProps(m_hHandle,CEDB_ALLOWREALLOC,
  347.                                 &wNumPropIdents,inputPropIDArray,
  348.                                 &pRecord->m_pbBuffer,&dwSize);
  349.  
  350.     int nNumProps = (int)wNumPropIdents;
  351.  
  352.     if(CeOID != NULL)
  353.     {
  354.         CEPROPVAL* PropValArray = (CEPROPVAL*)pRecord->m_pbBuffer;
  355.         CCeDBProp* pProp;
  356.         for(int n=0; n < (int)nNumProps; n++)
  357.         {
  358.             pProp = new CCeDBProp;
  359.             *pProp = CCeDBProp(PropValArray[n],CCeDBProp::NoCopy);
  360.             pProp->m_bDeletePtr = TRUE;
  361.             pRecord->AddProp(pProp);
  362.         }
  363.  
  364.         // Note: lpwstr and blob properties point into pRecord->m_pbBuffer.
  365.         // That was why we passed in CCePDBProp::NoCopy.  The record
  366.         // will free up the buffer when destructed or when Free() is called.
  367.  
  368.         if(m_bAutoSeekNext)
  369.             SeekNext();
  370.     }
  371.  
  372.     if(inputPropIDArray != NULL)
  373.         delete[] inputPropIDArray;
  374.  
  375.     return (CeOID != NULL);
  376. }
  377.  
  378.  
  379.  
  380.  
  381. // private function that implements the above.
  382.  
  383. BOOL CCeDBDatabase::WriteRecordProps(CCeDBRecord *pRecord,
  384.                                       int nMode /*= CCeDBDatabase::ModifyProps*/,
  385.                                        int nNumFilterProps /*= 0*/, 
  386.                                       CCeDBProp *PropFilterArray /*= NULL*/)
  387. {
  388.     AssertValid();
  389.  
  390.     CEOID CeOID;
  391.     CEPROPVAL* inputPropValArray = NULL;
  392.     BOOL bAll = FALSE;
  393.     int nNumRecordPropsAvail = pRecord->m_pPropArray.GetSize();
  394.     CCeDBProp* pProp;
  395.  
  396.     if(nNumFilterProps == 0) // zero means all
  397.     {
  398.         nNumFilterProps = nNumRecordPropsAvail;
  399.         bAll = TRUE;
  400.  
  401.         if(nNumFilterProps == 0)
  402.         {
  403.             ::SetLastError(ERROR_NO_DATA);
  404.             return FALSE;
  405.         }
  406.     }
  407.  
  408.     TRY
  409.     {
  410.         inputPropValArray = new CEPROPVAL[nNumFilterProps];
  411.     }
  412.     CATCH(CException,e)
  413.     {
  414.         ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  415.         return FALSE;
  416.     }
  417.     END_CATCH;
  418.  
  419.  
  420.     if(bAll)
  421.     {
  422.         for(int nCnt1=0; nCnt1 < (int)nNumFilterProps; nCnt1++)
  423.         {
  424.             pProp = pRecord->GetPropFromIndex(nCnt1);
  425.             CEPROPID propid = pProp->m_CePropVal.propid;
  426.             inputPropValArray[nCnt1] = pProp->m_CePropVal;
  427.         }
  428.     }
  429.     else
  430.     {
  431.         ASSERT(PropFilterArray != NULL);
  432.  
  433.         int nSkip = 0;
  434.         for(int nCnt1=0; nCnt1 < nNumFilterProps; nCnt1++)
  435.         {
  436.             for(int nCnt2=0; nCnt2 < nNumRecordPropsAvail; nCnt2++)
  437.             {
  438.                 pProp = pRecord->GetPropFromIndex(nCnt2);
  439.                 if(GET_PROPID_IDENT(PropFilterArray[nCnt1].m_CePropVal.propid) == 
  440.                    GET_PROPID_IDENT(pProp->m_CePropVal.propid))
  441.                 {
  442.                     inputPropValArray[nCnt1-nSkip] = pProp->m_CePropVal;
  443.                     break;
  444.                 }
  445.             }
  446.  
  447.             if(nCnt2 == nNumRecordPropsAvail) // requested ident not in record, so inc. skip
  448.                 nSkip++;
  449.         }
  450.  
  451.         nNumFilterProps -= nSkip; // adjust for skipped idents
  452.     }
  453.  
  454.  
  455.     if(nNumFilterProps == 0)
  456.     {
  457.         ::SetLastError(ERROR_NO_DATA);
  458.         delete[] inputPropValArray;
  459.         return FALSE;
  460.     }
  461.  
  462.     if(nMode == NewRecord)
  463.     {
  464.         CeOID = CeWriteRecordProps(m_hHandle,0,(WORD)nNumFilterProps,inputPropValArray);
  465.     }
  466.     else
  467.     {
  468.         if(nMode == DeleteProps)
  469.         {
  470.             for(int nCnt=0; nCnt < nNumFilterProps; nCnt++)
  471.                 inputPropValArray[nCnt].wFlags = CEDB_PROPDELETE;
  472.         }
  473.  
  474.         CeOID = CeWriteRecordProps(m_hHandle,GetCurrRecord(),
  475.                                      (WORD)nNumFilterProps,inputPropValArray);
  476.         if(nMode == DeleteProps)
  477.             ASSERT(CeOID == GetCurrRecord());
  478.     }
  479.  
  480.     
  481.     if(CeOID != NULL)
  482.     {
  483.         if(m_bAutoSeekNext)
  484.             SeekNext();
  485.     }
  486.  
  487.     if(inputPropValArray != NULL)
  488.         delete[] inputPropValArray;
  489.  
  490.     return (CeOID != NULL);
  491. }
  492.  
  493.  
  494. BOOL CCeDBDatabase::DeleteCurrRecordProps(int nNumProps /*= 0*/,
  495.                                            CCeDBProp *pPropArray /*= NULL*/)
  496. {
  497.     BOOL bRetVal;
  498.  
  499.     CCeDBRecord rec;    
  500.  
  501.     if(!ReadCurrRecord(&rec))  // inefficient
  502.         return FALSE;
  503.  
  504.     if(nNumProps == 0) // zero properties means delete all, so find out the properties. 
  505.     {                  // note: this is pretty inefficient
  506.  
  507.         nNumProps = rec.GetNumProps();
  508.         if(nNumProps == 0) // shouldn't occur!
  509.             return TRUE; // go ahead and say, yeah I'm okay
  510.  
  511.         TRY
  512.         {
  513.             pPropArray = new CCeDBProp[nNumProps];
  514.         }
  515.         CATCH(CException,e)
  516.         {
  517.             ::SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  518.             return FALSE;
  519.         }
  520.         END_CATCH;
  521.  
  522.         for(int n=0; n < nNumProps; n++)
  523.             pPropArray[n] = *rec.GetPropFromIndex(n);
  524.  
  525.         bRetVal = WriteRecordProps(&rec,DeleteProps,nNumProps,pPropArray);
  526.         delete[] pPropArray;
  527.     }
  528.     else
  529.     {
  530.         bRetVal = WriteRecordProps(&rec,DeleteProps,nNumProps,pPropArray);
  531.     }
  532.  
  533.     return bRetVal;
  534. }
  535.  
  536.  
  537.  
  538. //////////////////////////////////////////////////////////////////////
  539. // Queries 
  540. //////////////////////////////////////////////////////////////////////
  541.  
  542. // Note: AssertValid() is only needed in GetInfo() and SetInfo(), as
  543. // the other Get and Set methods call them.
  544.  
  545. CEDBASEINFO CCeDBDatabase::GetInfo(BOOL* pbOK) const
  546. {
  547.     AssertValid();
  548.  
  549.     CEOIDINFO CeObjectInfo;
  550.  
  551.     if(!CeOidGetInfo(m_CEOID,&CeObjectInfo))
  552.     {
  553.         *pbOK = FALSE;
  554.         memset(&CeObjectInfo.infDatabase,0,sizeof(CeObjectInfo.infDatabase));
  555.         return CeObjectInfo.infDatabase;
  556.     }
  557.     
  558.     ASSERT(CeObjectInfo.wObjType == OBJTYPE_DATABASE);
  559.  
  560.     *pbOK = TRUE;
  561.  
  562.     return CeObjectInfo.infDatabase;
  563. }
  564.  
  565. BOOL CCeDBDatabase::SetInfo(const CEDBASEINFO* pCeDBaseInfo)
  566. {
  567.     AssertValid();
  568.  
  569.     return CeSetDatabaseInfo(m_CEOID,(CEDBASEINFO*)pCeDBaseInfo);
  570. }
  571.  
  572.  
  573.  
  574. WORD CCeDBDatabase::GetNumRecords() const   
  575. { 
  576.     BOOL bOk;
  577.     return GetInfo(&bOk).wNumRecords;    
  578. }
  579.  
  580. // No SetNumRecords() counterpart
  581.  
  582. DWORD CCeDBDatabase::GetSize() const         
  583. { 
  584.     BOOL bOk;
  585.     return GetInfo(&bOk).dwSize;         
  586. }
  587.  
  588. // No SetSize() counterpart
  589.  
  590.  
  591. void CCeDBDatabase::GetName(LPWSTR szName) const         
  592. { 
  593.     BOOL bOK;
  594.     wcscpy(szName,GetInfo(&bOK).szDbaseName);
  595. }
  596.  
  597. BOOL CCeDBDatabase::SetName(LPCWSTR wszName)
  598. {
  599.     AssertValidDbaseName(wszName);
  600.  
  601.     CEDBASEINFO CeDBaseInfo;
  602.     memset(&CeDBaseInfo,0,sizeof(CeDBaseInfo));
  603.     wcsncpy(CeDBaseInfo.szDbaseName,wszName,CEDB_MAXDBASENAMELEN);
  604.     CeDBaseInfo.dwFlags = CEDB_VALIDNAME;
  605.  
  606.     return SetInfo(&CeDBaseInfo);
  607. }
  608.  
  609.  
  610. DWORD CCeDBDatabase::GetIdent() const
  611. { 
  612.     BOOL bOK;
  613.     return GetInfo(&bOK).dwDbaseType;
  614. }
  615.  
  616. BOOL CCeDBDatabase::SetIdent(DWORD dwIdent)
  617. {
  618.     CEDBASEINFO CeDBaseInfo;
  619.     memset(&CeDBaseInfo,0,sizeof(CeDBaseInfo));
  620.     CeDBaseInfo.dwDbaseType = dwIdent;
  621.     CeDBaseInfo.dwFlags = CEDB_VALIDTYPE;
  622.  
  623.     return SetInfo(&CeDBaseInfo);
  624. }
  625.  
  626.  
  627. FILETIME CCeDBDatabase::GetLastModified() const
  628. { 
  629.     BOOL bOK;
  630.     return GetInfo(&bOK).ftLastModified; 
  631. }
  632.  
  633. BOOL CCeDBDatabase::SetLastModified(FILETIME ftLastModified) 
  634. {
  635.     CEDBASEINFO CeDBaseInfo;
  636.     memset(&CeDBaseInfo,0,sizeof(CeDBaseInfo));
  637.     
  638.     CeDBaseInfo.ftLastModified = ftLastModified;
  639.     CeDBaseInfo.dwFlags = CEDB_VALIDMODTIME;
  640.  
  641.     return SetInfo(&CeDBaseInfo);
  642. }
  643.  
  644.  
  645.  
  646. // Note: pSortProps is assumed to be an array of at least CEDB_MAXSORTORDER elements!
  647. void CCeDBDatabase::GetSortProps(int *pnNumProps,CCeDBProp *pSortProps) const
  648. {
  649.     ASSERT(pnNumProps != NULL);
  650.     ASSERT(pSortProps != NULL);
  651.     
  652.     BOOL bOK;
  653.     CEDBASEINFO dbInfo = GetInfo(&bOK);
  654.     if(!bOK)
  655.     {
  656.         *pnNumProps = 0;
  657.         return;
  658.     }
  659.  
  660.     SORTORDERSPEC *pSpec;
  661.  
  662.     *pnNumProps = (int)dbInfo.wNumSortOrder;
  663.     ASSERT((*pnNumProps >= 0) && (*pnNumProps <= CEDB_MAXSORTORDER));
  664.  
  665.     for(int i=0; i < *pnNumProps; i++)
  666.     {
  667.         pSpec = &dbInfo.rgSortSpecs[i];
  668.         pSortProps[i] = CCeDBProp(CCeDBProp::CEVTtoType(GET_PROPID_CEVT(pSpec->propid)),
  669.                                    GET_PROPID_IDENT(pSpec->propid),
  670.                                    (WORD)pSpec->dwFlags);
  671.     }
  672. } 
  673.  
  674.  
  675. BOOL CCeDBDatabase::SetSortProps(int nNumProps,const CCeDBProp *pSortProps)
  676. {
  677.     ASSERT((nNumProps >= 0) && (nNumProps <= CEDB_MAXSORTORDER));
  678.     
  679.     CEDBASEINFO CeDBaseInfo;
  680.     int i;
  681.  
  682.     CeDBaseInfo.dwFlags       = CEDB_VALIDSORTSPEC;
  683.     CeDBaseInfo.wNumSortOrder = (WORD)nNumProps;
  684.  
  685.     if(nNumProps >= 0)
  686.         ASSERT(pSortProps != NULL);
  687.  
  688.     // The WinCE database doesn't allow multiple sort keys on a single property,
  689.     // so check for it
  690. #ifdef _DEBUG
  691.     for(i=0; i < nNumProps-1; i++)
  692.         for(int j=i+1; j < nNumProps; j++)
  693.             if(pSortProps[i].GetIdent() == pSortProps[j].GetIdent())
  694.                 ASSERT(FALSE); // A single property appeared more than once in the sort order!
  695. #endif
  696.  
  697.     for(i=0; i < nNumProps; i++)
  698.     {
  699.         CeDBaseInfo.rgSortSpecs[i].propid = pSortProps[i].GetPropid();
  700.         CeDBaseInfo.rgSortSpecs[i].dwFlags = (DWORD)pSortProps[i].m_wSortFlags;
  701.     }
  702.  
  703.     return SetInfo(&CeDBaseInfo);
  704. }
  705.  
  706. //////////////////////////////////////////////////////////////////////
  707.  
  708.  
  709. //////////////////////////////////////////////////////////////////////
  710. // Seeking operations
  711. //////////////////////////////////////////////////////////////////////
  712.  
  713.  
  714. // Note: the only seek operation that sets m_bEOF to TRUE is SeekNext(),
  715. // when it is unsuccessful.
  716. // m_bEOF is set to FALSE on all seek operations that are successful.
  717.  
  718. // O(dwIndex) if bFromEnd == FALSE, O(n) if bfromEnd == TRUE
  719. CEOID CCeDBDatabase::SeekToIndex(DWORD dwIndex,BOOL bFromEnd /*= FALSE*/) 
  720. {
  721.     AssertValid();
  722.  
  723.     DWORD dwNewIndex;
  724.     CEOID NewCeOID;
  725.     
  726.     if(bFromEnd)
  727.     {
  728.         NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_END,-(signed long)dwIndex,&dwNewIndex);
  729.     }
  730.     else
  731.     {
  732.         NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_BEGINNING,dwIndex,&dwNewIndex);
  733.         ASSERT(dwNewIndex == dwIndex);
  734.     }
  735.  
  736.     if(NewCeOID != 0)
  737.         m_bEOF = FALSE;
  738.  
  739.     return NewCeOID;
  740. }
  741.  
  742. // O(n)
  743. CEOID CCeDBDatabase::SeekToRecord(CEOID CeOID)
  744. {
  745.     AssertValid();
  746.  
  747.     DWORD dwNewIndex;
  748.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_CEOID,CeOID,&dwNewIndex);
  749.     if(NewCeOID != 0)
  750.         m_bEOF = FALSE;
  751.  
  752.     return NewCeOID; // may be zero if not found
  753. }
  754.  
  755.  
  756. // O(1)
  757. // This also maintains the EOF flag
  758. CEOID CCeDBDatabase::SeekNext()
  759. {
  760.     AssertValid();
  761.  
  762.     DWORD dwNewIndex;
  763.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_CURRENT,1,&dwNewIndex);
  764.  
  765.     m_bEOF = (NewCeOID == 0);
  766.  
  767.     return NewCeOID;
  768. } 
  769.  
  770. // O(n)
  771. CEOID CCeDBDatabase::SeekPrev()
  772. {
  773.     AssertValid();
  774.  
  775.     DWORD dwOldIndex,dwNewIndex;
  776.     CeSeekDatabase(m_hHandle,CEDB_SEEK_CURRENT,0,&dwOldIndex); 
  777.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_CURRENT,-1,&dwNewIndex);
  778.     if(NewCeOID != 0)
  779.         m_bEOF = FALSE;
  780.  
  781.     // Note: the behavior of CeSeekDatabase is that it doesn't go off the beginning or
  782.     // the end, but rather just stays there.  This wrapper fixes that.
  783.  
  784.     if(dwNewIndex == dwOldIndex)
  785.         return NULL;
  786.     else
  787.         return NewCeOID;
  788. } 
  789.  
  790.  
  791. // O(n)
  792. CEOID CCeDBDatabase::SeekFirstEqual(CCeDBProp& Prop)
  793. {
  794.     AssertValid();
  795.  
  796.     DWORD dwNewIndex;
  797.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_VALUEFIRSTEQUAL,(DWORD)&Prop.m_CePropVal,&dwNewIndex);
  798.     if(NewCeOID != 0)
  799.         m_bEOF = FALSE;
  800.     return NewCeOID;
  801. }
  802.  
  803. // O(1)
  804. CEOID CCeDBDatabase::SeekNextEqual(CCeDBProp& Prop)
  805. {
  806.     AssertValid();
  807.  
  808.     DWORD dwNewIndex;
  809.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_VALUENEXTEQUAL,(DWORD)&Prop.m_CePropVal,&dwNewIndex);
  810.     if(NewCeOID != 0)
  811.         m_bEOF = FALSE;
  812.     return NewCeOID;
  813. }
  814.  
  815. // O(n)
  816. CEOID CCeDBDatabase::SeekValueSmaller(CCeDBProp& Prop)
  817. {
  818.     AssertValid();
  819.  
  820.     DWORD dwNewIndex;
  821.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_VALUESMALLER,(DWORD)&Prop.m_CePropVal,&dwNewIndex);
  822.     if(NewCeOID != 0)
  823.         m_bEOF = FALSE;
  824.     return NewCeOID;
  825. }
  826.  
  827. // O(n)
  828. CEOID CCeDBDatabase::SeekValueGreater(CCeDBProp& Prop)
  829. {
  830.     AssertValid();
  831.  
  832.     DWORD dwNewIndex;
  833.     CEOID NewCeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_VALUEGREATER,(DWORD)&Prop.m_CePropVal,&dwNewIndex);
  834.     if(NewCeOID != 0)
  835.         m_bEOF = FALSE;
  836.     return NewCeOID;
  837. }
  838.  
  839. // O(1)
  840. DWORD CCeDBDatabase::GetCurrIndex() const
  841. {
  842.     AssertValid();
  843.  
  844.     DWORD dwCurrIndex;
  845.     CEOID CeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_CURRENT,0,&dwCurrIndex);
  846.  
  847.     if(CeOID == 0)
  848.         return (DWORD)-1;
  849.     else
  850.         return dwCurrIndex;
  851. }
  852.  
  853. // O(1)
  854. CEOID CCeDBDatabase::GetCurrRecord() const
  855. {
  856.     AssertValid();
  857.  
  858.     DWORD dwCurrIndex;
  859.     CEOID CeOID = CeSeekDatabase(m_hHandle,CEDB_SEEK_CURRENT,0,&dwCurrIndex);
  860.  
  861.     return CeOID;
  862. }
  863.  
  864.  
  865. //////////////////////////////////////////////////////////////////////
  866.  
  867.  
  868.  
  869.  
  870. //////////////////////////////////////////////////////////////////////
  871. // Diagnostics
  872. //////////////////////////////////////////////////////////////////////
  873.  
  874. void CCeDBDatabase::AssertValid() const
  875. {
  876. #ifdef _DEBUG
  877.     CObject::AssertValid();
  878. #endif
  879.     ASSERT(m_CEOID != NULL);
  880.     ASSERT(m_hHandle != INVALID_HANDLE_VALUE);
  881. }
  882.  
  883. void CCeDBDatabase::AssertValidDbaseName(LPCWSTR szName)
  884. {
  885.     int nLen = wcslen(szName);
  886.     ASSERT(nLen > 0);
  887.     ASSERT(nLen <= CEDB_MAXDBASENAMELEN-1);
  888. }
  889.  
  890. //////////////////////////////////////////////////////////////////////
  891.  
  892.  
  893.  
  894.  
  895.  
  896.  
  897.  
  898. //////////////////////////////////////////////////////////////////////
  899. // Constructors/destructor for CCeDBProp
  900. //////////////////////////////////////////////////////////////////////
  901.  
  902. // Default constructor places the value (long)0 
  903. // Note: in 32-bit Windows, long is the same as int
  904. CCeDBProp::CCeDBProp()
  905. {
  906.     m_bDeletePtr = FALSE; // assume that the user is allocating the memory for this
  907.                           // (set to TRUE if a CCeDBProp* gets added to a record and
  908.                           // it was allocated from within WCEDB.CPP)
  909.     InitProp(); // Note, all constructors need to call InitProp() first because
  910.             // each of the Set... helper functions call Delete(), which
  911.             // will free pointers.
  912.     SetLong(0);
  913. }
  914.  
  915.  
  916. // The following constructor creates valueless properties useful for
  917. // specifying sort keys.
  918. CCeDBProp::CCeDBProp(enum CCeDBProp::enType nType,WORD wIdent /*= 0*/,
  919.                        WORD wSortFlags /*= CCeDBProp::Sort_Ascending*/)
  920. {
  921.     m_bDeletePtr = FALSE; // see comment in CCeDBProp()
  922.     InitProp();
  923.     SetType(nType);
  924.     SetIdent(wIdent);
  925.     SetSortFlags(wSortFlags);
  926. };
  927.  
  928.  
  929. // The following constructor is used when reading a whole record from
  930. // the database with CeReadRecordProps(), which creates the CEPROPVAL's
  931. // with the wIdents for you.  If the CEPROPVAL doesn't have the identifier
  932. // in it, SetIdent() should be used to set it.
  933. CCeDBProp::CCeDBProp(CEPROPVAL CePropVal,enum CCeDBProp::enCopyMode nMode /*= Copy*/)
  934. {
  935.     m_bDeletePtr = FALSE;  // see comment in CCeDBProp()
  936.     InitProp();
  937.     if(CePropVal.propid == CEVT_LPWSTR)
  938.     {
  939.         SetString(CePropVal.val.lpwstr,nMode);
  940.         SetIdent(GET_PROPID_IDENT(CePropVal.propid));
  941.     }
  942.     else if(CePropVal.propid == CEVT_BLOB)
  943.     {
  944.         SetBlob(CePropVal.val.blob,nMode);
  945.         SetIdent(GET_PROPID_IDENT(CePropVal.propid));
  946.     }
  947.     else
  948.     {
  949.         m_CePropVal = CePropVal; // nMode doesn't apply
  950.     }
  951. }
  952.  
  953. CCeDBProp::CCeDBProp(short iVal,WORD wIdent /*= 0*/)
  954. {
  955.     m_bDeletePtr = FALSE;  // see comment in CCeDBProp()
  956.     InitProp();
  957.     SetShort(iVal);
  958.     SetIdent(wIdent);
  959. }
  960.  
  961. CCeDBProp::CCeDBProp(USHORT uiVal,WORD wIdent /*= 0*/)
  962. {
  963.     m_bDeletePtr = FALSE;  // see comment in CCeDBProp()
  964.     InitProp();
  965.     SetUShort(uiVal);
  966.     SetIdent(wIdent);
  967. }
  968.  
  969. CCeDBProp::CCeDBProp(long lVal,WORD wIdent /*= 0*/)
  970. {
  971.     m_bDeletePtr = FALSE; // see comment in CCeDBProp()
  972.     InitProp();
  973.     SetLong(lVal);
  974.     SetIdent(wIdent);
  975. }
  976.  
  977. CCeDBProp::CCeDBProp(ULONG ulVal,WORD wIdent /*= 0*/)
  978. {
  979.     m_bDeletePtr = FALSE;  // see comment in CCeDBProp()
  980.     InitProp();
  981.     SetULong(ulVal);
  982.     SetIdent(wIdent);
  983. }
  984.  
  985. CCeDBProp::CCeDBProp(FILETIME filetime,WORD wIdent /*= 0*/)
  986. {
  987.     m_bDeletePtr = FALSE;  // see comment in CCeDBProp()
  988.     InitProp();
  989.     SetFiletime(filetime);
  990.     SetIdent(wIdent);
  991. }
  992.  
  993. CCeDBProp::CCeDBProp(LPWSTR lpwstr,WORD wIdent /*= 0*/,enum CCeDBProp::enCopyMode nMode /*= CCeDBProp::Copy*/)
  994. {
  995.     m_bDeletePtr = FALSE;  // see comment in CCeDBProp()
  996.     ASSERT(lpwstr != NULL); // if you pass in 0, this constructor gets used.  
  997.     InitProp();
  998.     if(lpwstr != NULL)
  999.     {
  1000.         SetString(lpwstr,nMode);
  1001.         SetIdent(wIdent);
  1002.  
  1003.     }
  1004. }
  1005.  
  1006. CCeDBProp::CCeDBProp(CEBLOB blob,WORD wIdent /*= 0*/,enum CCeDBProp::enCopyMode nMode /*= CCeDBProp::Copy*/)
  1007. {
  1008.     m_bDeletePtr = FALSE;   // see comment in CCeDBProp()
  1009.     InitProp();
  1010.     SetBlob(blob,nMode);
  1011.     SetIdent(wIdent);
  1012. }
  1013.  
  1014.  
  1015. // copy constructor
  1016. CCeDBProp::CCeDBProp(CCeDBProp& prop)
  1017. {
  1018.     m_CePropVal = prop.m_CePropVal;
  1019.     m_bOwnsStringOrBlob = prop.m_bOwnsStringOrBlob; // transfer ownership to this, since prop
  1020.                                                     // is likely to be a temporary object
  1021.     m_wSortFlags = prop.m_wSortFlags;
  1022.     prop.m_bOwnsStringOrBlob = FALSE; // take away ownership from prop
  1023.     
  1024.     // m_bDeletePtr is not affected here
  1025. }
  1026.  
  1027. // assignment operator
  1028. CCeDBProp& CCeDBProp::operator=(const CCeDBProp& prop)
  1029. {
  1030.     FreeProp(); // free original object
  1031.     m_CePropVal = prop.m_CePropVal;
  1032.     m_wSortFlags = prop.m_wSortFlags;
  1033.     m_bOwnsStringOrBlob = FALSE; // leave ownership in prop 
  1034.  
  1035.     // m_bDeletePtr is not affected here
  1036.     return *this;
  1037. }
  1038.  
  1039. CCeDBProp::~CCeDBProp()
  1040. {
  1041.     FreeProp();
  1042. }
  1043.  
  1044. //////////////////////////////////////////////////////////////////////
  1045.  
  1046.  
  1047.  
  1048. //////////////////////////////////////////////////////////////////////
  1049. // Get/Set operations on CCeDBProp
  1050. //////////////////////////////////////////////////////////////////////
  1051.  
  1052.  
  1053. void CCeDBProp::SetIdent(WORD wIdent)
  1054. {
  1055.     SET_PROPID_IDENT(m_CePropVal.propid,wIdent);
  1056. }
  1057.  
  1058. WORD CCeDBProp::GetIdent() const
  1059. {
  1060.     return GET_PROPID_IDENT(m_CePropVal.propid);
  1061. }
  1062.  
  1063.  
  1064. /*private:*/ void CCeDBProp::SetCEVT(WORD wType)
  1065. {
  1066.     SET_PROPID_CEVT(m_CePropVal.propid,wType);
  1067. }
  1068.  
  1069. /*private:*/ WORD CCeDBProp::GetCEVT() const
  1070. {
  1071.     return GET_PROPID_CEVT(m_CePropVal.propid);
  1072. }
  1073.  
  1074.  
  1075. void CCeDBProp::SetType(CCeDBProp::enType nType)
  1076. {
  1077.     SET_PROPID_CEVT(m_CePropVal.propid,TypeToCEVT(nType));
  1078. }
  1079.  
  1080.  
  1081. CCeDBProp::enType CCeDBProp::GetType() const
  1082. {
  1083.     return CEVTtoType(GET_PROPID_CEVT(m_CePropVal.propid));
  1084. }
  1085.  
  1086.  
  1087. /*private: static */ CCeDBProp::enType CCeDBProp::CEVTtoType(WORD wType)
  1088. {
  1089.     if(wType == CEVT_I2)
  1090.         return CCeDBProp::Type_Short;
  1091.     else if(wType == CEVT_UI2)
  1092.         return CCeDBProp::Type_UShort;
  1093.     else if(wType == CEVT_I4)
  1094.         return CCeDBProp::Type_Long;
  1095.     else if(wType == CEVT_UI4)
  1096.         return CCeDBProp::Type_ULong;
  1097.     else if(wType == CEVT_FILETIME)
  1098.         return CCeDBProp::Type_Filetime;
  1099.     else if(wType == CEVT_LPWSTR)
  1100.         return CCeDBProp::Type_String;
  1101.     else if(wType == CEVT_BLOB)
  1102.         return CCeDBProp::Type_Blob;
  1103.     else 
  1104.         ASSERT(FALSE);
  1105.  
  1106.     // so compiler doesn't complain about control path not returning a value:
  1107.     return CCeDBProp::enType(0); 
  1108. }
  1109.  
  1110. /*private: static*/ WORD CCeDBProp::TypeToCEVT(CCeDBProp::enType nType)
  1111. {
  1112.     ASSERT((nType >= Type_Short) && (nType <= Type_Blob));
  1113.  
  1114.     static WORD wTypeMap[] = 
  1115.     {
  1116.         CEVT_I2,CEVT_UI2,CEVT_I4,CEVT_UI4,
  1117.         CEVT_FILETIME,CEVT_LPWSTR,CEVT_BLOB
  1118.     };
  1119.  
  1120.     return wTypeMap[nType];
  1121. }
  1122.  
  1123.  
  1124.  
  1125.  
  1126. /*private:*/ CEPROPID CCeDBProp::GetPropid() const 
  1127. {
  1128.     return m_CePropVal.propid;
  1129. }
  1130.  
  1131. // Note: there's no SetPropid().  We use SetType() and SetIdent() instead.
  1132.  
  1133.  
  1134. void CCeDBProp::SetSortFlags(WORD wSortFlags)
  1135. {
  1136.     ASSERT(0 == (wSortFlags & ~( Sort_Ascending  |
  1137.                                  Sort_Descending |
  1138.                                  Sort_CaseInsensitive |
  1139.                                  Sort_UnknownFirst |
  1140.                                  Sort_GenericOrder ) ) );
  1141.     m_wSortFlags = wSortFlags;
  1142. }
  1143.  
  1144. WORD CCeDBProp::GetSortFlags() const
  1145. {
  1146.     return m_wSortFlags;
  1147. }
  1148.  
  1149. void CCeDBProp::SetShort(short iVal)
  1150. {
  1151.     FreeProp(); // calls InitProp()
  1152.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_I2);
  1153.     m_CePropVal.val.iVal = iVal;
  1154. }
  1155.  
  1156. short CCeDBProp::GetShort() const
  1157. {
  1158.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_I2);
  1159.     return m_CePropVal.val.iVal;
  1160. }
  1161.  
  1162.  
  1163. void CCeDBProp::SetUShort(USHORT uiVal)
  1164. {
  1165.     FreeProp();  // calls InitProp()
  1166.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_UI2);
  1167.     m_CePropVal.val.uiVal = uiVal;
  1168. }
  1169.  
  1170. USHORT CCeDBProp::GetUShort() const
  1171. {
  1172.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_UI2);
  1173.     return m_CePropVal.val.uiVal;
  1174. }
  1175.  
  1176. void CCeDBProp::SetLong(long lVal)
  1177. {
  1178.     FreeProp();  // calls InitProp()
  1179.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_I4);
  1180.     m_CePropVal.val.lVal = lVal;
  1181. }
  1182.  
  1183. long CCeDBProp::GetLong() const
  1184. {
  1185.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_I4);
  1186.     return m_CePropVal.val.lVal;
  1187. }
  1188.  
  1189. void CCeDBProp::SetULong(ULONG ulVal)
  1190. {
  1191.     FreeProp();  // calls InitProp()
  1192.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_UI4);
  1193.     m_CePropVal.val.ulVal = ulVal;
  1194. }
  1195.  
  1196. ULONG CCeDBProp::GetULong() const
  1197. {
  1198.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_UI4);
  1199.     return m_CePropVal.val.ulVal;
  1200. }
  1201.  
  1202. void CCeDBProp::SetFiletime(FILETIME filetime)
  1203. {
  1204.     FreeProp();  // calls InitProp()
  1205.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_FILETIME);
  1206.     m_CePropVal.val.filetime = filetime;
  1207. }
  1208.  
  1209. FILETIME CCeDBProp::GetFiletime() const
  1210. {
  1211.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_FILETIME);
  1212.     return m_CePropVal.val.filetime;
  1213. }
  1214.  
  1215. void CCeDBProp::SetString(LPWSTR lpwstr,UINT nMode /*= CCeDBProp::Copy*/)
  1216. {
  1217.     FreeProp();  // calls InitProp()
  1218.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_LPWSTR);
  1219.  
  1220.     int nLen = wcslen(lpwstr)+sizeof(WCHAR);
  1221.     // Note: the length is not enforced by this wrapper method, but WinCE does have
  1222.     // a maximum set on its database records.
  1223.  
  1224.     switch(nMode)
  1225.     {
  1226.         case Copy:
  1227.             m_CePropVal.val.lpwstr = new WCHAR[nLen]; // throwable  
  1228.             wcscpy(m_CePropVal.val.lpwstr,lpwstr);
  1229.             m_bOwnsStringOrBlob = TRUE;
  1230.         break;
  1231.  
  1232.         case NoCopy:
  1233.             m_CePropVal.val.lpwstr = lpwstr;
  1234.             m_bOwnsStringOrBlob = FALSE;
  1235.         break;
  1236.  
  1237.         default:
  1238.             ASSERT(FALSE);
  1239.         break;
  1240.     }
  1241. }
  1242.  
  1243. LPWSTR CCeDBProp::GetString() const
  1244. {
  1245.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_LPWSTR);
  1246.     return m_CePropVal.val.lpwstr;
  1247. }
  1248.  
  1249. void CCeDBProp::SetBlob(CEBLOB blob,UINT nMode /*= CCeDBProp::Copy*/)
  1250. {
  1251.     FreeProp();  // calls InitProp()
  1252.  
  1253.     SET_PROPID_CEVT(m_CePropVal.propid,CEVT_BLOB);
  1254.     m_CePropVal.val.blob.dwCount = blob.dwCount;
  1255.     // Note: the length is not enforced by this wrapper method, but WinCE does have
  1256.     // a maximum set on its database records.
  1257.  
  1258.     switch(nMode)
  1259.     {
  1260.         case Copy:
  1261.             m_CePropVal.val.blob.lpb = new BYTE[blob.dwCount]; // throwable
  1262.             memcpy(m_CePropVal.val.blob.lpb,blob.lpb,blob.dwCount);
  1263.             m_bOwnsStringOrBlob = TRUE;
  1264.         break;
  1265.  
  1266.         case NoCopy:
  1267.             m_CePropVal.val.blob.lpb = blob.lpb;
  1268.             m_bOwnsStringOrBlob = FALSE;
  1269.         break;
  1270.     }
  1271. }
  1272.  
  1273. CEBLOB CCeDBProp::GetBlob() const
  1274. {
  1275.     ASSERT(GET_PROPID_CEVT(m_CePropVal.propid) == CEVT_BLOB);
  1276.     return m_CePropVal.val.blob;
  1277. }
  1278.  
  1279. //////////////////////////////////////////////////////////////////////
  1280.  
  1281.  
  1282.  
  1283. //////////////////////////////////////////////////////////////////////
  1284. // Other operations on CCeDBProp
  1285. //////////////////////////////////////////////////////////////////////
  1286.  
  1287. // Note: don't call InitProp() if there is currently data being pointed to by this class.
  1288. // InitProp() is private member function.
  1289. /*private:*/ void CCeDBProp::InitProp() 
  1290. {
  1291.     memset(&m_CePropVal,0,sizeof(CEPROPVAL));
  1292.     m_bOwnsStringOrBlob = FALSE;
  1293.     m_wSortFlags = 0;
  1294. }
  1295.  
  1296. void CCeDBProp::FreeProp()
  1297. {
  1298.     if((m_CePropVal.propid == CEVT_LPWSTR) && m_bOwnsStringOrBlob)
  1299.         delete[] m_CePropVal.val.lpwstr;
  1300.     else if((m_CePropVal.propid == CEVT_BLOB) && m_bOwnsStringOrBlob)
  1301.         delete[] m_CePropVal.val.blob.lpb;
  1302.  
  1303.     WORD wSaveIdent = GET_PROPID_IDENT(m_CePropVal.propid);
  1304.     InitProp();
  1305.     SET_PROPID_IDENT(m_CePropVal.propid,wSaveIdent);
  1306. }
  1307.  
  1308. //////////////////////////////////////////////////////////////////////
  1309.  
  1310.  
  1311.  
  1312.  
  1313. //////////////////////////////////////////////////////////////////////
  1314. // Implementation of CCeRecord
  1315. //////////////////////////////////////////////////////////////////////
  1316.  
  1317. CCeDBRecord::CCeDBRecord()
  1318. {
  1319.     m_pPropArray.SetSize(0);
  1320.     m_pbBuffer = NULL;
  1321. }
  1322.  
  1323. CCeDBRecord::~CCeDBRecord()
  1324. {
  1325.     FreeRecord(); 
  1326. }
  1327.  
  1328. // copy constructor
  1329. CCeDBRecord::CCeDBRecord(CCeDBRecord& rec)
  1330. {
  1331.     m_pPropArray.RemoveAll();
  1332.     m_pPropArray.Copy(rec.m_pPropArray);
  1333.     m_pbBuffer = NULL;  // no ownership of memory (let the original object keep it)
  1334. }
  1335.  
  1336. // assignment operator
  1337. CCeDBRecord& CCeDBRecord::operator=(const CCeDBRecord& rec)
  1338. {
  1339.     FreeRecord(); // free original object
  1340.     m_pPropArray.RemoveAll();
  1341.     m_pPropArray.Copy(rec.m_pPropArray);
  1342.     m_pbBuffer = NULL; // no ownership of memory (let the original object keep it)
  1343.     return *this;
  1344. }
  1345.  
  1346.  
  1347. int CCeDBRecord::GetNumProps() const
  1348. {
  1349.     return m_pPropArray.GetSize();
  1350. }
  1351.  
  1352. BOOL CCeDBRecord::AddProp(CCeDBProp *pProp)
  1353. {
  1354.     TRY
  1355.     {
  1356.         m_pPropArray.Add(pProp);
  1357.         pProp->m_bOwnsStringOrBlob = FALSE; // only want one ownership instance
  1358.     }
  1359.     CATCH(CMemoryException,e)
  1360.     {
  1361.         return FALSE;
  1362.     }
  1363.     END_CATCH
  1364.  
  1365.     return TRUE;
  1366. }
  1367.  
  1368. BOOL CCeDBRecord::AddProps(CCeDBProp* pPropArray,int nNumProps)
  1369. {
  1370.     for(int n=0; n < nNumProps; n++)
  1371.     {
  1372.         TRY
  1373.         {
  1374.             int nIndex = m_pPropArray.Add(pPropArray+n);
  1375.         }
  1376.         CATCH(CException,e)
  1377.         {
  1378.             return FALSE;
  1379.         }
  1380.         END_CATCH;
  1381.             
  1382.         pPropArray[n].m_bOwnsStringOrBlob = FALSE; // only want one ownership instance
  1383.     }
  1384.     return TRUE;
  1385. }
  1386.  
  1387. void CCeDBRecord::DeleteAllProps()
  1388. {
  1389.     FreeRecord();
  1390. }
  1391.  
  1392. void CCeDBRecord::DeleteProp(WORD wPropIdent)
  1393. {
  1394.     int nLength = m_pPropArray.GetSize();
  1395.  
  1396.     for(int n=0; n < nLength; n++)
  1397.     {
  1398.         if(GET_PROPID_IDENT(((CCeDBProp*)m_pPropArray[n])->m_CePropVal.propid) == wPropIdent)
  1399.         {
  1400.             if(((CCeDBProp*)m_pPropArray[n])->m_bDeletePtr)
  1401.                 free(m_pPropArray[n]);
  1402.             while(n < nLength-1)
  1403.             {
  1404.                 m_pPropArray[n] = m_pPropArray[n+1];
  1405.                 n++;
  1406.             }
  1407.             m_pPropArray.SetSize(--nLength);
  1408.             break;
  1409.         }
  1410.     }
  1411.  
  1412.     if(nLength == 0) // delete m_pbBuffer now (if there is one)
  1413.     {
  1414.         LocalFree(m_pbBuffer);
  1415.         m_pbBuffer = NULL;
  1416.     }
  1417. }
  1418.  
  1419. CCeDBProp* CCeDBRecord::GetPropFromIdent(WORD wPropIdent) const // query by wIdent?
  1420. {
  1421.     for(int n=0; n < m_pPropArray.GetSize(); n++)
  1422.     {
  1423.         if(GET_PROPID_IDENT(((CCeDBProp*)m_pPropArray[n])->m_CePropVal.propid) == wPropIdent)
  1424.             return *(((CCeDBProp **)m_pPropArray.GetData())+n);
  1425.     }
  1426.  
  1427.     return NULL;
  1428. }
  1429.  
  1430.  
  1431. CCeDBProp* CCeDBRecord::GetPropFromIndex(int n) const 
  1432. {
  1433.     ASSERT((n >= 0) && (n < m_pPropArray.GetSize()));
  1434.  
  1435.     return *(((CCeDBProp **)m_pPropArray.GetData())+n);
  1436. }
  1437.  
  1438.  
  1439. void CCeDBRecord::FreeRecord()
  1440. {
  1441.     int nLength = m_pPropArray.GetSize();
  1442.     for(int n=0; n < nLength; n++)
  1443.     {
  1444.         if(((CCeDBProp*)m_pPropArray[n])->m_bDeletePtr)
  1445.             free(m_pPropArray[n]);
  1446.     }
  1447.  
  1448.     m_pPropArray.SetSize(0); 
  1449.  
  1450.     if(m_pbBuffer != NULL)
  1451.     {
  1452.         LocalFree(m_pbBuffer);
  1453.         m_pbBuffer = NULL;
  1454.     }
  1455. }
  1456.  
  1457. //////////////////////////////////////////////////////////////////////
  1458.  
  1459. IMPLEMENT_DYNAMIC(CCeDBDatabase,CObject);
  1460. IMPLEMENT_DYNAMIC(CCeDBProp,CObject);
  1461.  
  1462.